package handler

import (
	"Data-API-MCP/backend/internal/domain/entity"
	"Data-API-MCP/backend/internal/domain/service"
	"Data-API-MCP/backend/internal/interfaces/http/response"
	"strconv"
	"time"

	"github.com/gin-gonic/gin"
)

// StatisticsHandler 统计处理器
type StatisticsHandler struct {
	statsService *service.StatisticsService
}

// NewStatisticsHandler 创建统计处理器
func NewStatisticsHandler(statsService *service.StatisticsService) *StatisticsHandler {
	return &StatisticsHandler{
		statsService: statsService,
	}
}

// RecordAPICall 记录API调用
// @Summary 记录API调用
// @Description 记录一次API调用的详细信息
// @Tags 统计
// @Accept json
// @Produce json
// @Param call body entity.APICall true "API调用记录"
// @Success 200 {object} response.Response{data=string} "成功"
// @Failure 400 {object} response.Response{} "请求错误"
// @Failure 500 {object} response.Response{} "服务器错误"
// @Router /statistics/api/call [post]
func (h *StatisticsHandler) RecordAPICall(c *gin.Context) {
	var call entity.APICall
	if err := c.ShouldBindJSON(&call); err != nil {
		response.Error(c, err)
		return
	}

	if err := h.statsService.RecordAPICall(c.Request.Context(), &call); err != nil {
		response.Error(c, err)
		return
	}

	response.Success(c, "API调用记录已保存")
}

// GetAPICallStats 获取API调用统计
// @Summary 获取API调用统计
// @Description 获取指定时间范围内的API调用统计信息
// @Tags 统计
// @Accept json
// @Produce json
// @Param start_time query string false "开始时间 (RFC3339格式，默认7天前)"
// @Success 200 {object} response.Response{data=map[string]interface{}} "成功"
// @Failure 400 {object} response.Response{} "请求错误"
// @Failure 500 {object} response.Response{} "服务器错误"
// @Router /statistics/api/stats [get]
func (h *StatisticsHandler) GetAPICallStats(c *gin.Context) {
	startTimeStr := c.DefaultQuery("start_time", time.Now().AddDate(0, 0, -7).Format(time.RFC3339))
	startTime, err := time.Parse(time.RFC3339, startTimeStr)
	if err != nil {
		response.Error(c, err)
		return
	}

	stats, err := h.statsService.GetAPICallStats(c.Request.Context(), startTime)
	if err != nil {
		response.Error(c, err)
		return
	}

	response.Success(c, stats)
}

// GetAPICallLogs 获取API调用日志
// @Summary 获取API调用日志
// @Description 获取指定API在时间范围内的调用日志
// @Tags 统计
// @Accept json
// @Produce json
// @Param api_id path string true "API ID"
// @Param start_time query string false "开始时间 (RFC3339格式，默认7天前)"
// @Param end_time query string false "结束时间 (RFC3339格式，默认当前时间)"
// @Success 200 {object} response.Response{data=[]entity.APICall} "成功"
// @Failure 400 {object} response.Response{} "请求错误"
// @Failure 500 {object} response.Response{} "服务器错误"
// @Router /statistics/api/logs/{api_id} [get]
func (h *StatisticsHandler) GetAPICallLogs(c *gin.Context) {
	apiID := c.Param("api_id")
	startTimeStr := c.DefaultQuery("start_time", time.Now().AddDate(0, 0, -7).Format(time.RFC3339))
	endTimeStr := c.DefaultQuery("end_time", time.Now().Format(time.RFC3339))

	startTime, err := time.Parse(time.RFC3339, startTimeStr)
	if err != nil {
		response.Error(c, err)
		return
	}

	endTime, err := time.Parse(time.RFC3339, endTimeStr)
	if err != nil {
		response.Error(c, err)
		return
	}

	calls, err := h.statsService.GetAPICallLogs(c.Request.Context(), apiID, startTime, endTime)
	if err != nil {
		response.Error(c, err)
		return
	}

	response.Success(c, calls)
}

// GetDatabaseStats 获取数据库连接统计
// @Summary 获取数据库连接统计
// @Description 获取所有数据库连接的统计信息
// @Tags 统计
// @Accept json
// @Produce json
// @Success 200 {object} response.Response{data=map[string]interface{}} "成功"
// @Failure 500 {object} response.Response{} "服务器错误"
// @Router /statistics/database [get]
func (h *StatisticsHandler) GetDatabaseStats(c *gin.Context) {
	stats, err := h.statsService.GetDatabaseStats(c.Request.Context())
	if err != nil {
		response.Error(c, err)
		return
	}

	response.Success(c, stats)
}

// GetDatabaseConnectionStats 获取数据库连接统计
// @Summary 获取数据库连接统计
// @Description 获取指定类型的数据库连接统计信息
// @Tags 统计
// @Accept json
// @Produce json
// @Param db_type path string true "数据库类型"
// @Success 200 {object} response.Response{data=[]entity.DatabaseConnectionStats} "成功"
// @Failure 500 {object} response.Response{} "服务器错误"
// @Router /statistics/database/{db_type} [get]
func (h *StatisticsHandler) GetDatabaseConnectionStats(c *gin.Context) {
	// 获取数据库类型
	dbType := c.Param("db_type")
	// 获取数据库连接统计
	stats, err := h.statsService.GetDatabaseConnectionStats(c.Request.Context(), dbType)
	if err != nil {
		response.Error(c, err)
		return
	}

	response.Success(c, stats)
}

// @Summary 记录数据库连接统计
// @Description 记录数据库连接的统计信息
// @Tags 统计
// @Accept json
// @Produce json
// @Param stats body entity.DatabaseConnectionStats true "数据库连接统计"
// @Success 200 {object} map[string]string
// @Failure 400 {object} map[string]string
// @Failure 500 {object} map[string]string
// @Router /statistics/database/connections [post]
func (h *StatisticsHandler) RecordDatabaseConnectionStats(c *gin.Context) {
	// 解析请求体
	var stats entity.DatabaseConnectionStats
	// 解析请求体
	if err := c.ShouldBindJSON(&stats); err != nil {
		response.Error(c, err)
		return
	}
	// 记录数据库连接统计
	if err := h.statsService.RecordDatabaseConnectionStats(c.Request.Context(), &stats); err != nil {
		response.Error(c, err)
		return
	}

	response.Success(c, "数据库连接统计已保存")
}

// @Summary 获取服务统计
// @Description 获取指定服务的统计信息
// @Tags 统计
// @Accept json
// @Produce json
// @Param service_id path string true "服务ID"
// @Success 200 {object} response.Response{data=entity.ServiceStats} "成功"
// @Failure 500 {object} response.Response{} "服务器错误"
// @Router /statistics/service/{service_id} [get]
func (h *StatisticsHandler) GetServiceStats(c *gin.Context) {
	// 获取服务ID
	serviceID := c.Param("service_id")
	// 获取服务统计
	stats, err := h.statsService.GetServiceStats(c.Request.Context(), serviceID)
	if err != nil {
		response.Error(c, err)
		return
	}

	response.Success(c, stats)
}

// GetServiceHealth 获取服务健康状态
// @Summary 获取服务健康状态
// @Description 获取指定服务的健康状态信息
// @Tags 统计
// @Accept json
// @Produce json
// @Param service_id path string true "服务ID"
// @Success 200 {object} response.Response{data=map[string]interface{}} "成功"
// @Failure 500 {object} response.Response{} "服务器错误"
// @Router /statistics/service/{service_id}/health [get]
func (h *StatisticsHandler) GetServiceHealth(c *gin.Context) {
	// 获取服务ID
	serviceID := c.Param("service_id")
	// 获取服务健康状态
	health, err := h.statsService.GetServiceHealth(c.Request.Context(), serviceID)
	if err != nil {
		response.Error(c, err)
		return
	}

	response.Success(c, health)
}

// GetTopServices 获取热门服务
// @Summary 获取热门服务
// @Description 获取调用次数最多的服务列表
// @Tags 统计
// @Accept json
// @Produce json
// @Param limit query int false "返回数量限制 (默认10)"
// @Success 200 {object} response.Response{data=[]entity.ServiceStats} "成功"
// @Failure 400 {object} response.Response{} "请求错误"
// @Failure 500 {object} response.Response{} "服务器错误"
// @Router /statistics/service/top [get]
func (h *StatisticsHandler) GetTopServices(c *gin.Context) {
	// 获取返回数量限制
	limitStr := c.DefaultQuery("limit", "10")
	// 解析返回数量限制
	limit, err := strconv.Atoi(limitStr)
	if err != nil {
		response.Error(c, err)
		return
	}
	// 获取热门服务
	services, err := h.statsService.GetTopServices(c.Request.Context(), limit)
	if err != nil {
		response.Error(c, err)
		return
	}

	response.Success(c, services)
}

// GetSystemHealth 获取系统健康状态
// @Summary 获取系统健康状态
// @Description 获取系统的健康状态信息
// @Tags 统计
// @Accept json
// @Produce json
// @Param service_id path string true "服务ID"
// @Param start_time query string false "开始时间 (RFC3339格式，默认7天前)"
// @Param end_time query string false "结束时间 (RFC3339格式，默认当前时间)"
// @Success 200 {array} entity.ServiceCallLog
// @Failure 400 {object} map[string]string
// @Failure 500 {object} map[string]string
// @Router /statistics/service/logs/{service_id} [get]
func (h *StatisticsHandler) GetServiceCallLogs(c *gin.Context) {
	// 获取服务ID
	serviceID := c.Param("service_id")
	// 获取开始时间
	startTimeStr := c.DefaultQuery("start_time", time.Now().AddDate(0, 0, -7).Format(time.RFC3339))
	// 获取结束时间
	endTimeStr := c.DefaultQuery("end_time", time.Now().Format(time.RFC3339))

	// 解析开始时间
	startTime, err := time.Parse(time.RFC3339, startTimeStr)
	if err != nil {
		response.Error(c, err)
		return
	}
	// 解析结束时间
	endTime, err := time.Parse(time.RFC3339, endTimeStr)
	if err != nil {
		response.Error(c, err)
		return
	}
	// 获取服务调用日志
	logs, err := h.statsService.GetServiceCallLogs(c.Request.Context(), serviceID, startTime, endTime)
	if err != nil {
		response.Error(c, err)
		return
	}

	response.Success(c, logs)
}

// @Summary 记录服务调用日志
// @Description 记录一次服务调用的详细日志
// @Tags 统计
// @Accept json
// @Produce json
// @Param log body entity.ServiceCallLog true "服务调用日志"
// @Success 200 {object} map[string]string
// @Failure 400 {object} map[string]string
// @Failure 500 {object} map[string]string
// @Router /statistics/service/logs [post]
func (h *StatisticsHandler) RecordServiceCallLog(c *gin.Context) {
	// 解析请求体
	var log entity.ServiceCallLog
	if err := c.ShouldBindJSON(&log); err != nil {
		response.Error(c, err)
		return
	}
	// 记录服务调用日志
	if err := h.statsService.RecordServiceCallLog(c.Request.Context(), &log); err != nil {
		response.Error(c, err)
		return
	}

	response.Success(c, "服务调用日志已保存")
}

// @Summary 获取API调用详情
// @Description 获取指定API调用的详细信息
// @Tags 统计
// @Accept json
// @Produce json
// @Param id path string true "API调用ID"
// @Success 200 {object} entity.APICall
// @Failure 400 {object} map[string]string
// @Failure 500 {object} map[string]string
// @Router /statistics/api/calls/{id} [get]
func (h *StatisticsHandler) GetAPICallDetail(c *gin.Context) {
	// 获取API调用详情
	id := c.Param("id")
	// 获取API调用详情
	call, err := h.statsService.GetAPICallDetail(c.Request.Context(), id)
	if err != nil {
		response.Error(c, err)
		return
	}
	response.Success(c, call)
}

// @Summary 获取API错误统计
// @Description 获取API错误统计信息
// @Tags 统计
// @Accept json
// @Produce json
// @Param start_time query string false "开始时间 (RFC3339格式，默认7天前)"
// @Success 200 {object} map[string]interface{}
// @Failure 400 {object} map[string]string
// @Failure 500 {object} map[string]string
// @Router /statistics/api/errors [get]
func (h *StatisticsHandler) GetAPIErrorStats(c *gin.Context) {
	// 获取API错误统计
	startTimeStr := c.DefaultQuery("start_time", time.Now().AddDate(0, 0, -7).Format(time.RFC3339))
	// 解析开始时间
	startTime, err := time.Parse(time.RFC3339, startTimeStr)
	if err != nil {
		response.Error(c, err)
		return
	}
	// 获取API错误统计
	stats, err := h.statsService.GetAPIErrorStats(c.Request.Context(), startTime)
	if err != nil {
		response.Error(c, err)
		return
	}

	response.Success(c, stats)
}

// @Summary 获取API性能统计
// @Description 获取API性能统计信息
// @Tags 统计
// @Accept json
// @Produce json
// @Param start_time query string false "开始时间 (RFC3339格式，默认7天前)"
// @Success 200 {object} map[string]interface{}
// @Failure 400 {object} map[string]string
// @Failure 500 {object} map[string]string
// @Router /statistics/api/performance [get]
func (h *StatisticsHandler) GetAPIPerformance(c *gin.Context) {
	// 获取API性能统计
	startTimeStr := c.DefaultQuery("start_time", time.Now().AddDate(0, 0, -7).Format(time.RFC3339))
	// 解析开始时间
	startTime, err := time.Parse(time.RFC3339, startTimeStr)
	if err != nil {
		response.Error(c, err)
		return
	}
	// 获取API性能统计
	stats, err := h.statsService.GetAPIPerformance(c.Request.Context(), startTime)
	if err != nil {
		response.Error(c, err)
		return
	}

	response.Success(c, stats)
}

// @Summary 获取数据库查询统计
// @Description 获取数据库查询统计信息
// @Tags 统计
// @Accept json
// @Produce json
// @Param start_time query string false "开始时间 (RFC3339格式，默认7天前)"
// @Success 200 {object} map[string]interface{}
// @Failure 400 {object} map[string]string
// @Failure 500 {object} map[string]string
// @Router /statistics/db/queries [get]
func (h *StatisticsHandler) GetDBQueryStats(c *gin.Context) {
	// 获取数据库查询统计
	startTimeStr := c.DefaultQuery("start_time", time.Now().AddDate(0, 0, -7).Format(time.RFC3339))
	// 解析开始时间
	startTime, err := time.Parse(time.RFC3339, startTimeStr)
	if err != nil {
		response.Error(c, err)
		return
	}

	// 获取数据库查询统计
	stats, err := h.statsService.GetDBQueryStats(c.Request.Context(), startTime)
	if err != nil {
		response.Error(c, err)
		return
	}

	response.Success(c, stats)
}

// @Summary 获取数据库性能统计
// @Description 获取数据库性能统计信息
// @Tags 统计
// @Accept json
// @Produce json
// @Success 200 {object} map[string]interface{}
// @Failure 500 {object} map[string]string
// @Router /statistics/db/performance [get]
func (h *StatisticsHandler) GetDBPerformance(c *gin.Context) {
	// 获取数据库性能统计
	stats, err := h.statsService.GetDBPerformance(c.Request.Context())
	if err != nil {
		response.Error(c, err)
		return
	}

	response.Success(c, stats)
}

// @Summary 获取数据库连接统计
// @Description 获取数据库连接统计信息
// @Tags 统计
// @Accept json
// @Produce json
// @Success 200 {object} map[string]interface{}
// @Failure 500 {object} map[string]string
// @Router /statistics/db/connections [get]
func (h *StatisticsHandler) GetDBConnectionStats(c *gin.Context) {
	// 获取数据库连接统计
	stats, err := h.statsService.GetDBConnectionStats(c.Request.Context())
	if err != nil {
		response.Error(c, err)
		return
	}

	response.Success(c, stats)
}

// @Summary 获取系统状态
// @Description 获取系统状态信息
// @Tags 统计
// @Accept json
// @Produce json
// @Success 200 {object} map[string]interface{}
// @Failure 500 {object} map[string]string
// @Router /statistics/system/status [get]
func (h *StatisticsHandler) GetSystemStatus(c *gin.Context) {
	// 获取系统状态
	status, err := h.statsService.GetSystemStatus(c.Request.Context())
	if err != nil {
		response.Error(c, err)
		return
	}

	response.Success(c, status)
}

// @Summary 获取系统资源使用情况
// @Description 获取系统资源使用情况统计
// @Tags 统计
// @Accept json
// @Produce json
// @Success 200 {object} map[string]interface{}
// @Failure 500 {object} map[string]string
// @Router /statistics/system/resources [get]
func (h *StatisticsHandler) GetSystemResources(c *gin.Context) {
	// 获取系统资源使用情况
	resources, err := h.statsService.GetSystemResources(c.Request.Context())
	if err != nil {
		response.Error(c, err)
		return
	}

	response.Success(c, resources)
}

// @Summary 获取系统日志
// @Description 获取系统日志信息
// @Tags 统计
// @Accept json
// @Produce json
// @Param start_time query string false "开始时间 (RFC3339格式，默认7天前)"
// @Param end_time query string false "结束时间 (RFC3339格式，默认当前时间)"
// @Success 200 {object} response.Response{data=[]entity.SystemLog} "成功"
// @Failure 400 {object} response.Response{} "请求错误"
// @Failure 500 {object} response.Response{} "服务器错误"
// @Router /statistics/system/logs [get]
func (h *StatisticsHandler) GetSystemLogs(c *gin.Context) {
	startTimeStr := c.DefaultQuery("start_time", time.Now().AddDate(0, 0, -7).Format(time.RFC3339))
	endTimeStr := c.DefaultQuery("end_time", time.Now().Format(time.RFC3339))

	// 解析开始时间
	startTime, err := time.Parse(time.RFC3339, startTimeStr)
	if err != nil {
		response.Error(c, err)
		return
	}

	// 解析结束时间
	endTime, err := time.Parse(time.RFC3339, endTimeStr)
	if err != nil {
		response.Error(c, err)
		return
	}

	// 获取系统日志
	logs, err := h.statsService.GetSystemLogs(c.Request.Context(), startTime, endTime)
	if err != nil {
		response.Error(c, err)
		return
	}

	response.Success(c, logs)
}

// GetSystemHealth 获取系统健康状态
// @Summary 获取系统健康状态
// @Description 获取系统的健康状态信息
// @Tags 统计
// @Accept json
// @Produce json
// @Success 200 {object} response.Response{data=map[string]interface{}} "成功"
// @Router /statistics/system/health [get]
func (h *StatisticsHandler) GetSystemHealth(c *gin.Context) {
	// 获取系统资源使用情况
	cpuUsage, err := h.statsService.GetCPUUsage(c.Request.Context())
	if err != nil {
		response.Error(c, err)
		return
	}
	// 获取内存使用情况
	memUsage, err := h.statsService.GetMemoryUsage(c.Request.Context())
	if err != nil {
		response.Error(c, err)
		return
	}
	// 获取磁盘使用情况
	diskUsage, err := h.statsService.GetDiskUsage(c.Request.Context())
	if err != nil {
		response.Error(c, err)
		return
	}

	// 获取服务健康状态
	services, err := h.statsService.GetServicesHealth(c.Request.Context())
	if err != nil {
		response.Error(c, err)
		return
	}

	// 构建健康状态响应
	health := map[string]interface{}{
		"cpu_usage":    cpuUsage,
		"memory_usage": memUsage,
		"disk_usage":   diskUsage,
		"services":     services,
		"status":       "healthy", // 可以根据实际情况设置状态
		"timestamp":    time.Now().Unix(),
	}

	response.Success(c, health)
}
